home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / dev / gg / ncurses-5.3.lha / ncurses-5.3 / tack / pad.c < prev    next >
C/C++ Source or Header  |  2002-10-24  |  44KB  |  1,958 lines
  1. /*
  2. ** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
  3. ** 
  4. ** This file is part of TACK.
  5. ** 
  6. ** TACK is free software; you can redistribute it and/or modify
  7. ** it under the terms of the GNU General Public License as published by
  8. ** the Free Software Foundation; either version 2, or (at your option)
  9. ** any later version.
  10. ** 
  11. ** TACK is distributed in the hope that it will be useful,
  12. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ** GNU General Public License for more details.
  15. ** 
  16. ** You should have received a copy of the GNU General Public License
  17. ** along with TACK; see the file COPYING.  If not, write to
  18. ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. ** Boston, MA 02111-1307, USA.
  20. */
  21.  
  22. #include <tack.h>
  23.  
  24. MODULE_ID("$Id: pad.c,v 1.2 2000/03/04 21:04:58 tom Exp $")
  25.  
  26. /* test the pad counts on the terminal */
  27.  
  28. static void pad_standard(struct test_list *, int *, int *);
  29. static void init_xon_xoff(struct test_list *, int *, int *);
  30. static void init_cup(struct test_list *, int *, int *);
  31. static void pad_rmxon(struct test_list *, int *, int *);
  32. static void pad_home1(struct test_list *, int *, int *);
  33. static void pad_home2(struct test_list *, int *, int *);
  34. static void pad_clear(struct test_list *, int *, int *);
  35. static void pad_ech(struct test_list *, int *, int *);
  36. static void pad_el1(struct test_list *, int *, int *);
  37. static void pad_el(struct test_list *, int *, int *);
  38. static void pad_smdc(struct test_list *, int *, int *);
  39. static void pad_dch(struct test_list *, int *, int *);
  40. static void pad_dch1(struct test_list *, int *, int *);
  41. static void pad_smir(struct test_list *, int *, int *);
  42. static void pad_ich(struct test_list *, int *, int *);
  43. static void pad_ich1(struct test_list *, int *, int *);
  44. static void pad_xch1(struct test_list *, int *, int *);
  45. static void pad_rep(struct test_list *, int *, int *);
  46. static void pad_cup(struct test_list *, int *, int *);
  47. static void pad_hd(struct test_list *, int *, int *);
  48. static void pad_hu(struct test_list *, int *, int *);
  49. static void pad_rin(struct test_list *, int *, int *);
  50. static void pad_il(struct test_list *, int *, int *);
  51. static void pad_indn(struct test_list *, int *, int *);
  52. static void pad_dl(struct test_list *, int *, int *);
  53. static void pad_xl(struct test_list *, int *, int *);
  54. static void pad_scrc(struct test_list *, int *, int *);
  55. static void pad_csrind(struct test_list *, int *, int *);
  56. static void pad_sccsrrc(struct test_list *, int *, int *);
  57. static void pad_csr_nel(struct test_list *, int *, int *);
  58. static void pad_csr_cup(struct test_list *, int *, int *);
  59. static void pad_ht(struct test_list *, int *, int *);
  60. static void pad_smso(struct test_list *, int *, int *);
  61. static void pad_smacs(struct test_list *, int *, int *);
  62. static void pad_crash(struct test_list *, int *, int *);
  63.  
  64. extern struct test_menu change_pad_menu;
  65.  
  66. /*
  67.    Any command found in this list, executed from a "Done" prompt
  68.    will force the default action to repeat rather than next.
  69. */
  70. const char *pad_repeat_test = {"ep-+<>"};
  71.  
  72. struct test_list pad_test_list[] = {
  73.     {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
  74.     {0, 0, 0, 0, "p) change padding", 0, &change_pad_menu},
  75.     {0, 0, 0, 0, "@) display statistics about the last test", dump_test_stats, 0},
  76.     {0, 0, 0, 0, "c) clear screen", menu_clear_screen, 0},
  77.     {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0},
  78.     {0, 0, 0, 0, txt_longer_test_time, longer_test_time, 0},
  79.     {0, 0, 0, 0, txt_shorter_test_time, shorter_test_time, 0},
  80.     {0, 0, 0, 0, txt_longer_augment, longer_augment, 0},
  81.     {0, 0, 0, 0, txt_shorter_augment, shorter_augment, 0},
  82.     /***
  83.        Phase 1: Test initialization and reset strings.
  84.     
  85.        (rs1) (rs2) (rs3) (is1) (is2) (is3) are very difficult to test.
  86.        They have no defined output.  To make matters worse, the cap
  87.        builder could partition (rs1) (rs2) (rs3) by length, leaving the
  88.        terminal in some unknown state between (rs1) and (rs2) or between
  89.        (r2) and (rs3).  Some reset strings clear the screen when done.
  90.     
  91.        We have no control over this.  The only thing we can do for
  92.        certain is to test the pad times by checking for overruns.
  93.     ***/
  94.     {MENU_NEXT, 3, "rs1", 0, 0, pad_standard, 0},
  95.     {MENU_NEXT, 3, "rs2", 0, 0, pad_standard, 0},
  96.     {MENU_NEXT, 3, "rs3", 0, 0, pad_standard, 0},
  97.     {MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_xon_xoff, 0},
  98.     {MENU_NEXT, 3, "is1", 0, 0, pad_standard, 0},
  99.     {MENU_NEXT, 3, "is2", 0, 0, pad_standard, 0},
  100.     {MENU_NEXT, 3, "is3", 0, 0, pad_standard, 0},
  101.     {MENU_NEXT, 3, "rmxon", "smxon", 0, pad_rmxon, 0},
  102.     {MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_cup, 0},
  103.     /*
  104.        Phase 2: Test home, screen clears and erases.
  105.     */
  106.     {MENU_NEXT, 0, "home", 0, 0, pad_home1, 0},
  107.     {MENU_NEXT, 0, "home) (nel", 0, 0, pad_home2, 0},
  108.     {MENU_NEXT | 1, 0, "clear", 0, 0, pad_clear, 0},
  109.     {MENU_NEXT | MENU_LM1, 0, "ed", 0, 0, pad_clear, 0},
  110.     {MENU_NEXT | MENU_80c, 0, "ech", 0, 0, pad_ech, 0},
  111.     {MENU_NEXT | MENU_80c, 0, "el1", "cub1 nel", 0, pad_el1, 0},
  112.     {MENU_NEXT | MENU_10c, 0, "el", "nel", 0, pad_el, 0},
  113.     /*
  114.        Phase 3: Character deletions and insertions
  115.     */
  116.     {MENU_NEXT, 0, "smdc) (rmdc", 0, 0, pad_smdc, 0},
  117.     {MENU_NEXT | MENU_80c, 0, "dch", "smdc rmdc", 0, pad_dch, 0},
  118.     {MENU_NEXT | MENU_80c, 0, "dch1", "smdc rmdc", 0, pad_dch1, 0},
  119.     {MENU_NEXT, 0, "smir) (rmir", 0, 0, pad_smir, 0},
  120.     {MENU_NEXT | MENU_90c, 0, "ich) (ip", "smir rmir", 0, pad_ich, 0},
  121.     {MENU_NEXT | MENU_90c, 0, "ich1) (ip", "smir rmir", 0, pad_ich1, 0},
  122.     {MENU_NEXT, 4, "ich1) (dch1", "smir rmir", 0, pad_xch1, 0},
  123.     {MENU_NEXT | MENU_90c, 0, "rep", 0, 0, pad_rep, 0},
  124.     /*
  125.        Phase 4: Test cursor addressing pads.
  126.     */
  127.     {MENU_NEXT, 0, "cup", 0, 0, pad_cup, 0},
  128.     /*
  129.        Phase 5: Test scrolling and cursor save/restore.
  130.     */
  131.     {MENU_NEXT, 0, "hd", 0, 0, pad_hd, 0},
  132.     {MENU_NEXT, 0, "hu", 0, 0, pad_hu, 0},
  133.     {MENU_NEXT | MENU_LM1 | 1, 0, "rin", 0, 0, pad_rin, 0},
  134.     {MENU_NEXT, 0, "ri", 0, 0, pad_rin, 0},
  135.     {MENU_NEXT | MENU_LM1 | 1, 0, "il", 0, 0, pad_il, 0},
  136.     {MENU_NEXT, 0, "il1", 0, 0, pad_il, 0},
  137.     {MENU_NEXT | MENU_LM1 | 1, 0, "indn", 0, 0, pad_indn, 0},
  138.     {MENU_NEXT, 0, "ind", 0, 0, pad_indn, 0},
  139.     {MENU_NEXT | MENU_LM1 | 1, 0, "dl", 0, 0, pad_dl, 0},
  140.     {MENU_NEXT, 0, "dl1", 0, 0, pad_dl, 0},
  141.     {MENU_NEXT, 0, "il1) (dl1", 0, 0, pad_xl, 0},
  142.     {MENU_NEXT, 0, "sc) (rc", 0, 0, pad_scrc, 0},
  143.     {MENU_NEXT | MENU_50l, 0, "csr) (ind", 0, 0, pad_csrind, 0},
  144.     {MENU_NEXT, 0, "sc) (csr) (rc", 0, 0, pad_sccsrrc, 0},
  145.     {MENU_NEXT, 0, "csr) (nel", "sc rc", 0, pad_csr_nel, 0},
  146.     {MENU_NEXT, 0, "csr) (cup", 0, 0, pad_csr_cup, 0},
  147.     /*
  148.        Phase 6: Test tabs.
  149.     */
  150.     {MENU_NEXT, 0, "ht", 0, 0, pad_ht, 0},
  151.     /*
  152.        Phase 7: Test character-set-switch pads.
  153.     */
  154.     {MENU_NEXT, 0, "smso) (rmso", 0, 0, pad_smso, 0},
  155.     {MENU_NEXT, 0, "smacs) (rmacs", 0, 0, pad_smacs, 0},
  156.     /*
  157.        Phase 8: Tests for miscellaneous mode-switch pads.
  158.     */
  159.     {MENU_NEXT, 3, "flash", 0, 0, pad_standard, 0},
  160.     {MENU_NEXT, 3, "smkx", 0, 0, pad_standard, 0},
  161.     {MENU_NEXT, 3, "rmkx", 0, 0, pad_standard, 0},
  162.     {MENU_NEXT, 3, "smm", 0, 0, pad_standard, 0},
  163.     {MENU_NEXT, 3, "rmm", 0, 0, pad_standard, 0},
  164.     /*
  165.        Phase 9: Test crash-and-burn properties of unpadded (clear).
  166.     */
  167.     {0, 0, "clear", "xon", "k) run clear test with no padding", pad_crash, 0},
  168.     {MENU_LAST, 0, 0, 0, 0, 0, 0}
  169. };
  170.  
  171. extern int test_complete;    /* counts number of tests completed */
  172.  
  173. /* globals */
  174. int hzcc;            /* horizontal character count */
  175. char letter;            /* current character being displayed */
  176. int letter_number;        /* points into letters[] */
  177. int augment, repeats;        /* number of characters (or lines) effected */
  178. char letters[] = "AbCdefghiJklmNopQrStuVwXyZ";
  179.  
  180. static char every_line[] = "This text should be on every line.";
  181. static char all_lines[] = "Each char on any line should be the same.  ";
  182. static char above_line[] = "The above lines should be all Xs.  ";
  183. static char no_visual[] = "This loop test has no visual failure indicator.  ";
  184.  
  185. /*
  186. **    pad_standard(test_list, status, ch)
  187. **
  188. **    Run a single cap pad test.
  189. */
  190. static void
  191. pad_standard(
  192.     struct test_list *t,
  193.     int *state,
  194.     int *ch)
  195. {
  196.     const char *long_name;
  197.     char *cap;
  198.     int l = 2, i;
  199.     char tbuf[128];
  200.  
  201.     if ((cap = get_string_cap_byname(t->caps_done, &long_name))) {
  202.         sprintf(tbuf, "(%s) %s, start testing", t->caps_done,
  203.             long_name);
  204.         if (skip_pad_test(t, state, ch, tbuf)) {
  205.             return;
  206.         }
  207.         i = 1;
  208.         pad_test_startup(1);
  209.         do {
  210.             if (i >= columns) {
  211.                 page_loop();
  212.                 l++;
  213.                 i = 1;
  214.             }
  215.             tt_putp(cap);
  216.             putchp(letter);
  217.             i++;
  218.         } while(still_testing());
  219.         pad_test_shutdown(t, 0);
  220.         if (l >= lines) {
  221.             home_down();
  222.         } else {
  223.             put_crlf();
  224.         }
  225.         ptextln(no_visual);
  226.     } else {
  227.         CAP_NOT_FOUND;
  228.         /* Note: get_string_cap_byname() always sets long_name */
  229.         sprintf(temp, "(%s) %s, not present.  ", t->caps_done,
  230.             long_name);
  231.         ptext(temp);
  232.     }
  233.     pad_done_message(t, state, ch);
  234. }
  235.  
  236. /*
  237. **    init_xon_xoff(test_list, status, ch)
  238. **
  239. **    Initialize the xon_xoff values
  240. */
  241. static void
  242. init_xon_xoff(
  243.     struct test_list *t GCC_UNUSED,
  244.     int *state GCC_UNUSED,
  245.     int *ch GCC_UNUSED)
  246. {
  247.     /* the reset strings may dink with the XON/XOFF modes */
  248.     if (select_xon_xoff == 0 && exit_xon_mode) {
  249.         tc_putp(exit_xon_mode);
  250.     }
  251.     if (select_xon_xoff == 1 && enter_xon_mode) {
  252.         tc_putp(enter_xon_mode);
  253.     }
  254. }
  255.  
  256. /*
  257. **    pad_rmxon(test_list, status, ch)
  258. **
  259. **    Test (rmxon) exit XON/XOFF mode
  260. */
  261. static void
  262. pad_rmxon(
  263.     struct test_list *t,
  264.     int *state,
  265.     int *ch)
  266. {
  267.     if (select_xon_xoff == 0 && exit_xon_mode) {
  268.         pad_standard(t, state, ch);
  269.     }
  270. }
  271.  
  272. /*
  273. **    init_cup(test_list, status, ch)
  274. **
  275. **    Send the initialization strings for XON/XOFF and (smcup)
  276. **    Stop pad testing if clear screen is missing.
  277. */
  278. static void
  279. init_cup(
  280.     struct test_list *t,
  281.     int *state,
  282.     int *ch)
  283. {
  284.     init_xon_xoff(t, state, ch);
  285.     if (enter_ca_mode) {
  286.         tc_putp(enter_ca_mode);
  287.     }
  288.     if (!can_clear_screen) {
  289.         ptext("(clear) clear screen not present,");
  290.         ptext(" pad processing terminated.  ");
  291.         pad_done_message(t, state, ch);
  292.         if (*ch == 0 || *ch == 'n' || *ch == 's' || *ch == 'r') {
  293.             *ch = '?';
  294.         }
  295.         return;
  296.     }
  297. }
  298.  
  299. /*
  300. **    pad_home1(test_list, status, ch)
  301. **
  302. **    Test (home) when (am) is set.
  303. */
  304. static void
  305. pad_home1(
  306.     struct test_list *t,
  307.     int *state,
  308.     int *ch)
  309. {
  310.     int j, k;
  311.  
  312.     if (can_go_home && auto_right_margin) {
  313.         /*
  314.            truly brain damaged terminals will fail this test because
  315.            they cannot accept data at full rate
  316.         */
  317.         if (skip_pad_test(t, state, ch, "(home) Home start testing")) {
  318.             return;
  319.         }
  320.         pad_test_startup(1);
  321.         do {
  322.             go_home();
  323.             for (j = 1; j < lines; j++) {
  324.                 for (k = 0; k < columns; k++) {
  325.                     if (k & 0xF) {
  326.                         put_this(letter);
  327.                     } else {
  328.                         put_this('.');
  329.                     }
  330.                 }
  331.                 SLOW_TERMINAL_EXIT;
  332.             }
  333.             NEXT_LETTER;
  334.         } while(still_testing());
  335.         pad_test_shutdown(t, 0);
  336.         ptext("All the dots should line up.  ");
  337.         pad_done_message(t, state, ch);
  338.         put_clear();
  339.     }
  340. }
  341.  
  342. /*
  343. **    pad_home2(test_list, status, ch)
  344. **
  345. **    Test (home) and (nel).  (am) is reset.
  346. */
  347. static void
  348. pad_home2(
  349.     struct test_list *t,
  350.     int *state,
  351.     int *ch)
  352. {
  353.     int j, k;
  354.  
  355.     if (can_go_home) {
  356.         if (skip_pad_test(t, state, ch,
  357.             "(home) Home, (nel) newline start testing")) {
  358.             return;
  359.         }
  360.         pad_test_startup(1);
  361.         do {
  362.             go_home();
  363.             for (j = 1; j < lines; j++) {
  364.                 for (k = 2; k < columns; k++) {
  365.                     if (k & 0xF) {
  366.                         put_this(letter);
  367.                     } else {
  368.                         put_this('.');
  369.                     }
  370.                 }
  371.                 put_crlf();    /* this does the (nel) */
  372.                 SLOW_TERMINAL_EXIT;
  373.             }
  374.             NEXT_LETTER;
  375.         } while(still_testing());
  376.         pad_test_shutdown(t, 0);
  377.         ptext("All the dots should line up.  ");
  378.         pad_done_message(t, state, ch);
  379.         put_clear();
  380.     }
  381. }
  382.  
  383. /*
  384. **    pad_clear(test_list, status, ch)
  385. **
  386. **    Test (clear) and (ed)
  387. **    run the clear screen tests (also clear-to-end-of-screen)
  388. **
  389. **    0) full page
  390. **    1) sparse page
  391. **    2) short lines
  392. **    3) one full line
  393. **    4) one short line
  394. */
  395. static void
  396. pad_clear(
  397.     struct test_list *t,
  398.     int *state,
  399.     int *ch)
  400. {
  401.     const char *end_message = 0;
  402.     const char *txt;
  403.     int j, k, is_clear;
  404.     int clear_select;        /* select the test number */
  405.  
  406.     is_clear = t->flags & 1;
  407.     clear_select = auto_right_margin ? 0 : 1;
  408.     if (is_clear) {
  409.         txt = "(clear) clear-screen start testing";
  410.     } else {
  411.         if (!clr_eos) {
  412.             CAP_NOT_FOUND;
  413.             ptext("(ed) erase-to-end-of-display, not present.  ");
  414.             pad_done_message(t, state, ch);
  415.             return;
  416.         }
  417.         txt = "(ed) erase-to-end-of-display start testing";
  418.     }
  419.     if (skip_pad_test(t, state, ch, txt)) {
  420.         return;
  421.     }
  422.     if (enter_am_mode) {
  423.         tc_putp(enter_am_mode);
  424.         clear_select = 0;
  425.     }
  426.     for (; clear_select < 5; clear_select++) {
  427.         if (augment > lines || is_clear || !cursor_address) {
  428.             augment = lines;
  429.         } else {
  430.             if (augment <= 1) {
  431.                 augment = 2;
  432.             }
  433.             if (augment < lines) {
  434.                 put_clear();
  435.                 tt_putparm(cursor_address, 1,
  436.                     lines - augment - 1, 0);
  437.                 ptextln("This line should not be erased (ed)");
  438.             }
  439.         }
  440.         repeats = augment;
  441.         switch (clear_select) {
  442.         case 0:
  443.             end_message = "Clear full screen.  ";
  444.             break;
  445.         case 1:
  446.             end_message = "Clear sparse screen.  ";
  447.             if (cursor_down) {
  448.                 break;
  449.             }
  450.             clear_select++;
  451.             /* FALLTHRU */
  452.         case 2:
  453.             end_message = "Clear one character per line.  ";
  454.             if (newline) {
  455.                 break;
  456.             }
  457.             clear_select++;
  458.             /* FALLTHRU */
  459.         case 3:
  460.             end_message = "Clear one full line.  ";
  461.             break;
  462.         case 4:
  463.             end_message = "Clear single short line.  ";
  464.             break;
  465.         }
  466.         pad_test_startup(0);
  467.         do {
  468.             switch (clear_select) {
  469.             case 0:    /* full screen test */
  470.                 for (j = 1; j < repeats; j++) {
  471.                     for (k = 0; k < columns; k++) {
  472.                         if (k & 0xF) {
  473.                             put_this(letter);
  474.                         } else {
  475.                             put_this('.');
  476.                         }
  477.                     }
  478.                     SLOW_TERMINAL_EXIT;
  479.                 }
  480.                 break;
  481.             case 1:    /* sparse screen test */
  482.                 for (j = columns - repeats; j > 2; j--) {
  483.                     put_this(letter);
  484.                 }
  485.                 for (j = 2; j < repeats; j++) {
  486.                     tt_putp(cursor_down);
  487.                     put_this(letter);
  488.                 }
  489.                 break;
  490.             case 2:    /* short lines */
  491.                 for (j = 2; j < repeats; j++) {
  492.                     put_this(letter);
  493.                     tt_putp(newline);
  494.                 }
  495.                 put_this(letter);
  496.                 break;
  497.             case 3:    /* one full line */
  498.                 for (j = columns - 5; j > 1; j--) {
  499.                     put_this(letter);
  500.                 }
  501.                 break;
  502.             case 4:    /* one short line */
  503.                 put_str("Erase this!");
  504.                 break;
  505.             }
  506.             if (is_clear) {
  507.                 put_clear();
  508.             } else {
  509.                 if (augment == lines) {
  510.                     go_home();
  511.                 } else {
  512.                     tt_putparm(cursor_address, 1,
  513.                         lines - repeats, 0);
  514.                 }
  515.                 tt_tputs(clr_eos, repeats);
  516.             }
  517.             NEXT_LETTER;
  518.         } while(still_testing());
  519.         pad_test_shutdown(t, 1);
  520.         ptext(end_message);
  521.  
  522.         pad_done_message(t, state, ch);
  523.  
  524.         if (*ch != 0 && *ch != 'n') {
  525.             return;
  526.         }
  527.     }
  528. }
  529.  
  530. /*
  531. **    pad_ech(test_list, status, ch)
  532. **
  533. **    Test (ech) erase characters
  534. */
  535. static void
  536. pad_ech(
  537.     struct test_list *t,
  538.     int *state,
  539.     int *ch)
  540. {
  541.     int i, j;
  542.  
  543.     if (!erase_chars) {
  544.         CAP_NOT_FOUND;
  545.         ptext("(ech) Erase-characters, not present.  ");
  546.         pad_done_message(t, state, ch);
  547.         return;
  548.     }
  549.     if (skip_pad_test(t, state, ch,
  550.         "(ech) Erase-characters start testing")) {
  551.         return;
  552.     }
  553.     if (augment > columns - 2) {
  554.         augment = columns - 2;
  555.     }
  556.     pad_test_startup(1);
  557.     do {
  558.         go_home();
  559.         for (i = 2; i < lines; i++) {
  560.             for (j = 0; j <= repeats; j++) {
  561.                 putchp(letter);
  562.             }
  563.             put_cr();
  564.             tt_putparm(erase_chars, repeats, repeats, 0);
  565.             put_crlf();
  566.             SLOW_TERMINAL_EXIT;
  567.         }
  568.         for (i = 1; i <= repeats; i++) {
  569.             putchp(' ');
  570.         }
  571.         putchp(letter);
  572.         put_crlf();
  573.         NEXT_LETTER;
  574.     } while(still_testing());
  575.     pad_test_shutdown(t, 0);
  576.     ptext(all_lines);
  577.     pad_done_message(t, state, ch);
  578.     put_clear();
  579. }
  580.  
  581. /*
  582. **    pad_el1(test_list, status, ch)
  583. **
  584. **    Test (el1) erase to start of line also (cub1) and (nel)
  585. */
  586. static void
  587. pad_el1(
  588.     struct test_list *t,
  589.     int *state,
  590.     int *ch)
  591. {
  592.     int i, j;
  593.  
  594.     if (!clr_bol) {
  595.         CAP_NOT_FOUND;
  596.         ptext("(el1) Erase-to-beginning-of-line, not present.  ");
  597.         pad_done_message(t, state, ch);
  598.         return;
  599.     }
  600.     if (skip_pad_test(t, state, ch,
  601.         "(el1) Erase-to-beginning-of-line start testing")) {
  602.         return;
  603.     }
  604.     if (augment > columns - 2) {
  605.         augment = columns - 2;
  606.     }
  607.     pad_test_startup(1);
  608.     do {
  609.         go_home();
  610.         for (i = 2; i < lines; i++) {
  611.             for (j = 0; j <= repeats; j++) {
  612.                 putchp(letter);
  613.             }
  614.             tt_putp(cursor_left);
  615.             tt_putp(cursor_left);
  616.             tt_tputs(clr_bol, repeats);
  617.             put_crlf();
  618.             SLOW_TERMINAL_EXIT;
  619.         }
  620.         for (i = 1; i <= repeats; i++) {
  621.             putchp(' ');
  622.         }
  623.         putchp(letter);
  624.         put_crlf();
  625.         NEXT_LETTER;
  626.     } while(still_testing());
  627.     pad_test_shutdown(t, 0);
  628.     ptext(all_lines);
  629.     pad_done_message(t, state, ch);
  630.     put_clear();
  631. }
  632.  
  633. /*
  634. **    pad_el(test_list, status, ch)
  635. **
  636. **    Test (el) clear to end of line also (nel)
  637. */
  638. static void
  639. pad_el(
  640.     struct test_list *t,
  641.     int *state,
  642.     int *ch)
  643. {
  644.     int i, j;
  645.  
  646.     if (!clr_eol) {
  647.         CAP_NOT_FOUND;
  648.         ptext("(el) Clear-to-end-of-line, not present.  ");
  649.         pad_done_message(t, state, ch);
  650.         return;
  651.     }
  652.     if (skip_pad_test(t, state, ch,
  653.         "(el) Clear-to-end-of-line start testing")) {
  654.         return;
  655.     }
  656.     hzcc = columns * 8 / 10;    /* horizontal character count */
  657.     if (augment > hzcc) {
  658.         augment = hzcc;
  659.     }
  660.     pad_test_startup(1);
  661.     do {
  662.         go_home();
  663.         for (i = 2; i < lines; i++) {
  664.             for (j = -1; j < augment; j++) {
  665.                 putchp(letter);
  666.             }
  667.             put_cr();
  668.             putchp(letter);
  669.             tt_putp(clr_eol);
  670.             put_crlf();
  671.             SLOW_TERMINAL_EXIT;
  672.         }
  673.         putchp(letter);
  674.         put_crlf();
  675.         NEXT_LETTER;
  676.     } while(still_testing());
  677.     pad_test_shutdown(t, 0);
  678.     ptext(all_lines);
  679.     pad_done_message(t, state, ch);
  680.     put_clear();
  681. }
  682.  
  683. /*
  684. **    pad_smdc(test_list, status, ch)
  685. **
  686. **    Test (smdc) (rmdc) Delete mode
  687. */
  688. static void
  689. pad_smdc(
  690.     struct test_list *t,
  691.     int *state,
  692.     int *ch)
  693. {
  694.     int i;
  695.  
  696.     if (!enter_delete_mode) {
  697.         CAP_NOT_FOUND;
  698.         ptext("(smdc) Enter-delete-mode");
  699.         if (!exit_delete_mode) {
  700.             ptext(", (rmdc) Exit-delete-mode");
  701.         }
  702.         ptext(", not present.  ");
  703.         pad_done_message(t, state, ch);
  704.         return;
  705.     }
  706.     if (skip_pad_test(t, state, ch,
  707.         "(smdc) (rmdc) Enter/Exit-delete-mode start testing")) {
  708.         return;
  709.     }
  710.     pad_test_startup(1);
  711.     do {
  712.         page_loop();
  713.         for (i = 1; i < columns; i++) {
  714.             tt_putp(enter_delete_mode);
  715.             tt_putp(exit_delete_mode);
  716.             putchp(letter);
  717.         }
  718.     } while(still_testing());
  719.     pad_test_shutdown(t, 0);
  720.     home_down();
  721.     ptext(no_visual);
  722.     pad_done_message(t, state, ch);
  723.     put_clear();
  724. }
  725.  
  726. /*
  727. **    pad_dch(test_list, status, ch)
  728. **
  729. **    Test (smdc) (rmdc) Delete mode and (dch)
  730. */
  731. static void
  732. pad_dch(
  733.     struct test_list *t,
  734.     int *state,
  735.     int *ch)
  736. {
  737.     int i, j;
  738.  
  739.     if (!parm_dch) {
  740.         CAP_NOT_FOUND;
  741.         ptext("(dch) Delete-characters, not present.  ");
  742.         pad_done_message(t, state, ch);
  743.         return;
  744.     }
  745.     if (skip_pad_test(t, state, ch,
  746.         "(dch) Delete-characters start testing")) {
  747.         return;
  748.     }
  749.     hzcc = columns * 8 / 10;    /* horizontal character count */
  750.     if (augment > hzcc) {
  751.         augment = hzcc;
  752.     }
  753.     pad_test_startup(1);
  754.     do {
  755.         go_home();
  756.         for (i = 2; i < lines; i++) {
  757.             for (j = 0; j <= repeats; j++) {
  758.                 putchp(letter);
  759.             }
  760.             put_cr();
  761.             tt_putp(enter_delete_mode);
  762.             tt_putparm(parm_dch, repeats, repeats, 0);
  763.             tt_putp(exit_delete_mode);
  764.             put_crlf();
  765.             SLOW_TERMINAL_EXIT;
  766.         }
  767.         putchp(letter);
  768.         put_crlf();
  769.         NEXT_LETTER;
  770.     } while(still_testing());
  771.     pad_test_shutdown(t, 0);
  772.     home_down();
  773.     ptext(all_lines);
  774.     pad_done_message(t, state, ch);
  775.     put_clear();
  776. }
  777.  
  778. /*
  779. **    pad_dch1(test_list, status, ch)
  780. **
  781. **    Test (smdc) (rmdc) Delete mode and (dch1)
  782. */
  783. static void
  784. pad_dch1(
  785.     struct test_list *t,
  786.     int *state,
  787.     int *ch)
  788. {
  789.     int i, j;
  790.  
  791.     if (!delete_character) {
  792.         if (parm_dch) {
  793.             /* if the other one is defined then its OK */
  794.             return;
  795.         }
  796.         CAP_NOT_FOUND;
  797.         ptext("(dch1) Delete-character, not present.  ");
  798.         pad_done_message(t, state, ch);
  799.         return;
  800.     }
  801.     if (skip_pad_test(t, state, ch,
  802.         "(dch1) Delete-character start testing")) {
  803.         return;
  804.     }
  805.     hzcc = columns * 8 / 10;    /* horizontal character count */
  806.     if (augment > hzcc) {
  807.         augment = hzcc;
  808.     }
  809.     pad_test_startup(1);
  810.     do {
  811.         go_home();
  812.         for (i = 2; i < lines; i++) {
  813.             for (j = -1; j < augment; j++) {
  814.                 putchp(letter);
  815.             }
  816.             put_cr();
  817.             tt_putp(enter_delete_mode);
  818.             for (j = 0; j < augment; j++) {
  819.                 tt_putp(delete_character);
  820.             }
  821.             tt_putp(exit_delete_mode);
  822.             put_crlf();
  823.             SLOW_TERMINAL_EXIT;
  824.         }
  825.         putchp(letter);
  826.         put_crlf();
  827.         NEXT_LETTER;
  828.     } while(still_testing());
  829.     pad_test_shutdown(t, 0);
  830.     ptext(all_lines);
  831.     pad_done_message(t, state, ch);
  832.     put_clear();
  833. }
  834.  
  835. /*
  836. **    pad_smir(test_list, status, ch)
  837. **
  838. **    Test (smir) (rmir) Insert mode
  839. */
  840. static void
  841. pad_smir(
  842.     struct test_list *t,
  843.     int *state,
  844.     int *ch)
  845. {
  846.     int i;
  847.  
  848.     if (!enter_insert_mode) {
  849.         CAP_NOT_FOUND;
  850.         ptext("(smir) Enter-insert-mode");
  851.         if (!exit_insert_mode) {
  852.             ptext(", (rmir) Exit-insert-mode");
  853.         }
  854.         ptext(", not present.  ");
  855.         pad_done_message(t, state, ch);
  856.         return;
  857.     }
  858.     if (skip_pad_test(t, state, ch,
  859.         "(smir) (rmir) Enter/Exit-insert-mode start testing")) {
  860.         return;
  861.     }
  862.     pad_test_startup(1);
  863.     do {
  864.         page_loop();
  865.         for (i = 1; i < columns; i++) {
  866.             tt_putp(enter_insert_mode);
  867.             tt_putp(exit_insert_mode);
  868.             putchp(letter);
  869.         }
  870.     } while(still_testing());
  871.     pad_test_shutdown(t, 0);
  872.     home_down();
  873.     ptext(no_visual);
  874.     pad_done_message(t, state, ch);
  875.     put_clear();
  876. }
  877.  
  878. /*
  879. **    pad_ich(test_list, status, ch)
  880. **
  881. **    Test (smir) (rmir) Insert mode and (ich) and (ip)
  882. */
  883. static void
  884. pad_ich(
  885.     struct test_list *t,
  886.     int *state,
  887.     int *ch)
  888. {
  889.     int i, j;
  890.  
  891.     if (!parm_ich) {
  892.         CAP_NOT_FOUND;
  893.         ptext("(ich) Insert-characters, not present.  ");
  894.         pad_done_message(t, state, ch);
  895.         return;
  896.     }
  897.     if (skip_pad_test(t, state, ch,
  898.         "(ich) Insert-characters, (ip) Insert-padding start testing")) {
  899.         return;
  900.     }
  901.     j = columns * 9 / 10;
  902.     if (augment > j) {
  903.         augment = j;
  904.     }
  905.     pad_test_startup(1);
  906.     do {
  907.         go_home();
  908.         for (i = 2; i < lines; i++) {
  909.             putchp(letter);
  910.             put_cr();
  911.             tt_putp(enter_insert_mode);
  912.             replace_mode = 0;
  913.             tt_putparm(parm_ich, repeats, repeats, 0);
  914.             tt_putp(exit_insert_mode);
  915.             replace_mode = 1;
  916.             put_crlf();
  917.             SLOW_TERMINAL_EXIT;
  918.         }
  919.         for (i = 0; i < repeats; i++) {
  920.             putchp(' ');
  921.         }
  922.         putchp(letter);
  923.         NEXT_LETTER;
  924.         put_crlf();
  925.     } while(still_testing());
  926.     pad_test_shutdown(t, 0);
  927.     ptext(all_lines);
  928.     pad_done_message(t, state, ch);
  929.     tc_putp(exit_insert_mode);
  930. }
  931.  
  932. /*
  933. **    pad_ich1(test_list, status, ch)
  934. **
  935. **    Test (smir) (rmir) Insert mode and (ich1) and (ip)
  936. */
  937. static void
  938. pad_ich1(
  939.     struct test_list *t,
  940.     int *state,
  941.     int *ch)
  942. {
  943.     int i, j;
  944.  
  945.     if (!insert_character) {
  946.         CAP_NOT_FOUND;
  947.         ptext("(ich1) Insert-character, not present.  ");
  948.         pad_done_message(t, state, ch);
  949.         return;
  950.     }
  951.     if (skip_pad_test(t, state, ch,
  952.         "(ich1) Insert-character, (ip) Insert-padding start testing")) {
  953.         return;
  954.     }
  955.     if (augment > columns - 2) {
  956.         augment = columns - 2;
  957.     }
  958.     pad_test_startup(1);
  959.     do {
  960.         put_clear();
  961.         for (i = 2; i < lines; i++) {
  962.             putchp(letter);
  963.             put_cr();
  964.             tt_putp(enter_insert_mode);
  965.             replace_mode = 0;
  966.             if (!insert_padding && !insert_character) {
  967.                 /* only enter/exit is needed */
  968.                 for (j = 0; j < augment; j++) {
  969.                     putchp('.');
  970.                 }
  971.             } else {
  972.                 for (j = 0; j < augment; j++) {
  973.                     tt_putp(insert_character);
  974.                     putchp('.');
  975.                     tt_putp(insert_padding);
  976.                 }
  977.             }
  978.             tt_putp(exit_insert_mode);
  979.             replace_mode = 1;
  980.             put_crlf();
  981.             SLOW_TERMINAL_EXIT;
  982.         }
  983.         for (j = 0; j < augment; j++) {
  984.             putchp('.');
  985.         }
  986.         putchp(letter);
  987.         NEXT_LETTER;
  988.         put_crlf();
  989.     } while(still_testing());
  990.     pad_test_shutdown(t, 0);
  991.     ptext(all_lines);
  992.     pad_done_message(t, state, ch);
  993.     tc_putp(exit_insert_mode);
  994. }
  995.  
  996. /*
  997. **    pad_xch1(test_list, status, ch)
  998. **
  999. **    Test (ich1) (ip) (dch1)
  1000. */
  1001. static void
  1002. pad_xch1(
  1003.     struct test_list *t,
  1004.     int *state,
  1005.     int *ch)
  1006. {
  1007.     static char xch1[] =
  1008.     "This line should not be garbled. It should be left justified.";
  1009.  
  1010.     if (enter_insert_mode || exit_insert_mode ||
  1011.         enter_delete_mode || exit_delete_mode ||
  1012.         !insert_character || !delete_character) {
  1013.         /* this test is quietly ignored */
  1014.         return;
  1015.     }
  1016.     if (skip_pad_test(t, state, ch,
  1017.         "(ich1) Insert-character, (dch1) Delete-character start testing")) {
  1018.         return;
  1019.     }
  1020.     put_crlf();
  1021.     ptext(xch1);
  1022.     put_cr();
  1023.     pad_test_startup(0);
  1024.     do {
  1025.         tt_putp(insert_character);
  1026.         tt_putp(delete_character);
  1027.     } while(still_testing());
  1028.     pad_test_shutdown(t, 1);
  1029.     ptextln(xch1);
  1030.     ptext("The preceding two lines should be the same.  ");
  1031.     pad_done_message(t, state, ch);
  1032. }
  1033.  
  1034. /*
  1035. **    pad_rep(test_list, status, ch)
  1036. **
  1037. **    Test (rep) repeat character
  1038. */
  1039. static void
  1040. pad_rep(
  1041.     struct test_list *t,
  1042.     int *state,
  1043.     int *ch)
  1044. {
  1045.     int i, j;
  1046.  
  1047.     if (!repeat_char) {
  1048.         CAP_NOT_FOUND;
  1049.         ptext("(rep) Repeat-character, not present.  ");
  1050.         pad_done_message(t, state, ch);
  1051.         return;
  1052.     }
  1053.     if (skip_pad_test(t, state, ch,
  1054.         "(rep) Repeat-character start testing")) {
  1055.         return;
  1056.     }
  1057.     if (augment > columns - 2) {
  1058.         augment = columns - 2;
  1059.     }
  1060.     if (augment < 2) {
  1061.         augment = 2;
  1062.     }
  1063.     pad_test_startup(1);
  1064.     do {
  1065.         go_home();
  1066.         for (i = 2; i < lines; i++) {
  1067.             tt_putparm(repeat_char, repeats, letter, repeats);
  1068.             put_crlf();
  1069.         }
  1070.         for (j = 0; j < repeats; j++) {
  1071.             putchp(letter);
  1072.         }
  1073.         put_crlf();
  1074.         NEXT_LETTER;
  1075.     } while(still_testing());
  1076.     pad_test_shutdown(t, 0);
  1077.     ptextln(all_lines);
  1078.     pad_done_message(t, state, ch);
  1079. }
  1080.  
  1081. /*
  1082. **    pad_cup(test_list, status, ch)
  1083. **
  1084. **    Test (cup) Cursor address
  1085. */
  1086. static void
  1087. pad_cup(
  1088.     struct test_list *t,
  1089.     int *state,
  1090.     int *ch)
  1091. {
  1092.     int i, j, l, r, c;
  1093.  
  1094.     if (!cursor_address) {
  1095.         CAP_NOT_FOUND;
  1096.         ptext("(cup) Cursor-address not present.  ");
  1097.         pad_done_message(t, state, ch);
  1098.         return;
  1099.     }
  1100.     if (skip_pad_test(t, state, ch,
  1101.         "(cup) Cursor-address start testing")) {
  1102.         return;
  1103.     }
  1104.     put_clear();
  1105.     ptext("Each line should be filled with the same letter.  There should");
  1106.     ptext(" be no gaps, or single letters scattered over the screen.  ");
  1107.     if (char_count + 15 > columns) {
  1108.         put_crlf();
  1109.     }
  1110.     if (((lines - line_count) & 1) == 0) {
  1111.         /* this removes the gap in the middle of the test when the
  1112.         number of lines is odd.  */
  1113.         put_crlf();
  1114.     }
  1115.     r = line_count;
  1116.     c = char_count;
  1117.     l = (columns - 4) >> 1;
  1118.     pad_test_startup(0);
  1119.     do {
  1120.         for (i = 1; i + i + r < lines; i++) {
  1121.             for (j = 0; j <= l; j++) {
  1122.                 tt_putparm(cursor_address, 1, r + i, j);
  1123.                 putchp(letter);
  1124.                 tt_putparm(cursor_address, 1, r + i, l + l + 1 - j);
  1125.                 putchp(letter);
  1126.                 tt_putparm(cursor_address, 1, lines - i, j);
  1127.                 putchp(letter);
  1128.                 tt_putparm(cursor_address, 1, lines - i, l + l + 1 - j);
  1129.                 putchp(letter);
  1130.             }
  1131.             SLOW_TERMINAL_EXIT;
  1132.         }
  1133.         NEXT_LETTER;
  1134.     } while(still_testing());
  1135.     pad_test_shutdown(t, 0);
  1136.     tt_putparm(cursor_address, 1, line_count = r, char_count = c);
  1137.     pad_done_message(t, state, ch);
  1138.     put_clear();
  1139. }
  1140.  
  1141. /*
  1142. **    pad_hd(test_list, status, ch)
  1143. **
  1144. **    Test (hd) Half down
  1145. */
  1146. static void
  1147. pad_hd(
  1148.     struct test_list *t,
  1149.     int *state,
  1150.     int *ch)
  1151. {
  1152.     int i, j, k;
  1153.  
  1154.     if (!down_half_line) {
  1155.         CAP_NOT_FOUND;
  1156.         ptext("(hd) Half-line-down not present.  ");
  1157.         pad_done_message(t, state, ch);
  1158.         return;
  1159.     }
  1160.     if (skip_pad_test(t, state, ch,
  1161.         "(hd) Half-line-down start testing")) {
  1162.         return;
  1163.     }
  1164.     pad_test_startup(1);
  1165.     do {
  1166.         for (i = 1; i < columns; i += 2) {
  1167.             for (j = 1; j < i; ++j) {
  1168.                 putchp(' ');
  1169.             }
  1170.             tt_putp(down_half_line);
  1171.             for (k = lines + lines; k > 4; k--) {
  1172.                 if (j++ >= columns) {
  1173.                     break;
  1174.                 }
  1175.                 tt_putp(down_half_line);
  1176.                 putchp(letter);
  1177.             }
  1178.             go_home();
  1179.             SLOW_TERMINAL_EXIT;
  1180.         }
  1181.         NEXT_LETTER;
  1182.     } while(still_testing());
  1183.     pad_test_shutdown(t, 0);
  1184.     pad_done_message(t, state, ch);
  1185.     put_clear();
  1186. }
  1187.  
  1188. /*
  1189. **    pad_hu(test_list, status, ch)
  1190. **
  1191. **    Test (hu) Half line up
  1192. */
  1193. static void
  1194. pad_hu(
  1195.     struct test_list *t,
  1196.     int *state,
  1197.     int *ch)
  1198. {
  1199.     int i, j, k;
  1200.  
  1201.     if (!up_half_line) {
  1202.         CAP_NOT_FOUND;
  1203.         ptext("(hu) Half-line-up not present.  ");
  1204.         pad_done_message(t, state, ch);
  1205.         return;
  1206.     }
  1207.     if (skip_pad_test(t, state, ch,
  1208.         "(hu) Half-line-up start testing")) {
  1209.         return;
  1210.     }
  1211.     pad_test_startup(1);
  1212.     do {
  1213.         for (i = 1; i < columns; i += 2) {
  1214.             home_down();
  1215.             for (j = 1; j < i; ++j) {
  1216.                 putchp(' ');
  1217.             }
  1218.             tt_putp(up_half_line);
  1219.             for (k = lines + lines; k > 4; k--) {
  1220.                 if (j++ >= columns) {
  1221.                     break;
  1222.                 }
  1223.                 tt_putp(up_half_line);
  1224.                 putchp(letter);
  1225.             }
  1226.             SLOW_TERMINAL_EXIT;
  1227.         }
  1228.         go_home();
  1229.         NEXT_LETTER;
  1230.     } while(still_testing());
  1231.     pad_test_shutdown(t, 0);
  1232.     pad_done_message(t, state, ch);
  1233.     put_clear();
  1234. }
  1235.  
  1236. /*
  1237. **    pad_rin(test_list, status, ch)
  1238. **
  1239. **    Test (rin) and (ri) Reverse index
  1240. */
  1241. static void
  1242. pad_rin(
  1243.     struct test_list *t,
  1244.     int *state,
  1245.     int *ch)
  1246. {
  1247.     int i;
  1248.     const char *start_message;
  1249.  
  1250.     if (t->flags & 1) {
  1251.         /* rin */
  1252.         if (!parm_rindex) {
  1253.             CAP_NOT_FOUND;
  1254.             ptext("(rin) Scroll-reverse-n-lines not present.  ");
  1255.             pad_done_message(t, state, ch);
  1256.             return;
  1257.         }
  1258.         start_message = "(rin) Scroll-reverse-n-lines start testing";
  1259.     } else {
  1260.         /* ri */
  1261.         if (!scroll_reverse) {
  1262.             CAP_NOT_FOUND;
  1263.             ptext("(ri) Scroll-reverse not present.  ");
  1264.             pad_done_message(t, state, ch);
  1265.             return;
  1266.         }
  1267.         start_message = "(ri) Scroll-reverse start testing";
  1268.         augment = 1;
  1269.     }
  1270.     if (skip_pad_test(t, state, ch, start_message)) {
  1271.         return;
  1272.     }
  1273.     pad_test_startup(1);
  1274.     do {
  1275.         sprintf(temp, "%d\r", test_complete);
  1276.         put_str(temp);
  1277.         if (scroll_reverse && augment == 1) {
  1278.             tt_putp(scroll_reverse);
  1279.         } else {
  1280.             tt_putparm(parm_rindex, repeats, repeats, 0);
  1281.         }
  1282.     } while(still_testing());
  1283.     put_str("This line should be on the bottom.\r");
  1284.     if (scroll_reverse && augment == 1) {
  1285.         for (i = 1; i < lines; i++) {
  1286.             tt_putp(scroll_reverse);
  1287.         }
  1288.     } else {
  1289.         tt_putparm(parm_rindex, lines - 1, lines - 1, 0);
  1290.     }
  1291.     putln("The screen should have text on the bottom line.");
  1292.     sprintf(temp, "Scroll reverse %d line%s.  ", augment,
  1293.         augment == 1 ? "" : "s");
  1294.     put_str(temp);
  1295.     pad_test_shutdown(t, 0);
  1296.     pad_done_message(t, state, ch);
  1297.     put_clear();
  1298. }
  1299.  
  1300. /*
  1301. **    pad_il(test_list, status, ch)
  1302. **
  1303. **    Test (il) and (il1) Insert line
  1304. */
  1305. static void
  1306. pad_il(
  1307.     struct test_list *t,
  1308.     int *state,
  1309.     int *ch)
  1310. {
  1311.     int i;
  1312.     const char *start_message;
  1313.  
  1314.     if (t->flags & 1) {
  1315.         /* il */
  1316.         if (!parm_insert_line) {
  1317.             CAP_NOT_FOUND;
  1318.             ptext("(il) Insert-lines not present.  ");
  1319.             pad_done_message(t, state, ch);
  1320.             return;
  1321.         }
  1322.         start_message = "(il) Insert-lines start testing";
  1323.     } else {
  1324.         /* il1 */
  1325.         if (!insert_line) {
  1326.             CAP_NOT_FOUND;
  1327.             ptext("(il1) Insert-line not present.  ");
  1328.             pad_done_message(t, state, ch);
  1329.             return;
  1330.         }
  1331.         start_message = "(il1) Insert-line start testing";
  1332.         augment = 1;
  1333.     }
  1334.     if (skip_pad_test(t, state, ch, start_message)) {
  1335.         return;
  1336.     }
  1337.     pad_test_startup(1);
  1338.     do {
  1339.         sprintf(temp, "%d\r", test_complete);
  1340.         put_str(temp);
  1341.         if (insert_line && repeats == 1) {
  1342.             tt_putp(insert_line);
  1343.         } else {
  1344.             tt_putparm(parm_insert_line, repeats, repeats, 0);
  1345.         }
  1346.     } while(still_testing());
  1347.     put_str("This line should be on the bottom.\r");
  1348.     if (scroll_reverse && augment == 1) {
  1349.         for (i = 1; i < lines; i++) {
  1350.             tt_putp(insert_line);
  1351.         }
  1352.     } else {
  1353.         tt_putparm(parm_insert_line, lines - 1, lines - 1, 0);
  1354.     }
  1355.     putln("The screen should have text on the bottom line.");
  1356.     sprintf(temp, "Insert %d line%s.  ", augment,
  1357.         augment == 1 ? "" : "s");
  1358.     put_str(temp);
  1359.     pad_test_shutdown(t, 0);
  1360.     pad_done_message(t, state, ch);
  1361.     put_clear();
  1362. }
  1363.  
  1364. /*
  1365. **    pad_indn(test_list, status, ch)
  1366. **
  1367. **    Test (indn) and (ind) Scroll forward
  1368. */
  1369. static void
  1370. pad_indn(
  1371.     struct test_list *t,
  1372.     int *state,
  1373.     int *ch)
  1374. {
  1375.     int i;
  1376.     const char *start_message;
  1377.  
  1378.     if (t->flags & 1) {
  1379.         /* indn */
  1380.         if (!parm_index) {
  1381.             CAP_NOT_FOUND;
  1382.             ptext("(indn) Scroll-forward-n-lines not present.  ");
  1383.             pad_done_message(t, state, ch);
  1384.             return;
  1385.         }
  1386.         start_message = "(indn) Scroll-forward-n-lines start testing";
  1387.     } else {
  1388.         /* ind */
  1389.         if (!scroll_forward && over_strike) {
  1390.             CAP_NOT_FOUND;
  1391.             ptext("(ind) Scroll-forward not tested on overstrike terminals.  ");
  1392.             pad_done_message(t, state, ch);
  1393.             return;
  1394.         }
  1395.         start_message = "(ind) Scroll-forward start testing";
  1396.         augment = 1;
  1397.     }
  1398.     if (skip_pad_test(t, state, ch, start_message)) {
  1399.         return;
  1400.     }
  1401.     pad_test_startup(1);
  1402.     /* go to the bottom of the screen */
  1403.     home_down();
  1404.     do {
  1405.         sprintf(temp, "%d\r", test_complete);
  1406.         put_str(temp);
  1407.         if (augment > 1) {
  1408.             tt_putparm(parm_index, repeats, repeats, 0);
  1409.         } else {
  1410.             put_ind();
  1411.         }
  1412.     } while(still_testing());
  1413.     put_str("This line should be on the top.\r");
  1414.     if (augment == 1) {
  1415.         for (i = 1; i < lines; i++) {
  1416.             put_ind();
  1417.         }
  1418.     } else {
  1419.         tt_putparm(parm_index, lines - 1, lines - 1, 0);
  1420.     }
  1421.     go_home();
  1422.     sprintf(temp, "\nScroll forward %d line%s.  ", augment,
  1423.         augment == 1 ? "" : "s");
  1424.     put_str(temp);
  1425.     pad_test_shutdown(t, 0);
  1426.     pad_done_message(t, state, ch);
  1427. }
  1428.  
  1429. /*
  1430. **    pad_dl(test_list, status, ch)
  1431. **
  1432. **    Test (dl) and (dl1) Delete lines
  1433. */
  1434. static void
  1435. pad_dl(
  1436.     struct test_list *t,
  1437.     int *state,
  1438.     int *ch)
  1439. {
  1440.     int i = 0;
  1441.     const char *start_message;
  1442.  
  1443.     if (t->flags & 1) {
  1444.         /* dl */
  1445.         if (!parm_delete_line) {
  1446.             CAP_NOT_FOUND;
  1447.             ptext("(dl) Delete-lines not present.  ");
  1448.             pad_done_message(t, state, ch);
  1449.             return;
  1450.         }
  1451.         start_message = "(dl) Delete-lines start testing";
  1452.     } else {
  1453.         /* dl1 */
  1454.         if (!delete_line) {
  1455.             CAP_NOT_FOUND;
  1456.             ptext("(dl1) Delete-line not present.  ");
  1457.             pad_done_message(t, state, ch);
  1458.             return;
  1459.         }
  1460.         start_message = "(dl1) Delete-line start testing";
  1461.         augment = 1;
  1462.     }
  1463.     if (skip_pad_test(t, state, ch, start_message)) {
  1464.         return;
  1465.     }
  1466.     pad_test_startup(1);
  1467.     do {
  1468.         sprintf(temp, "%d\r", test_complete);
  1469.         if ((i & 0x7f) == 0 && augment < lines - 1) {
  1470.             go_home();
  1471.             putln(temp);
  1472.         }
  1473.         put_str(temp);
  1474.         if (repeats || !delete_line) {
  1475.             tt_putparm(parm_delete_line, repeats, repeats, 0);
  1476.         } else {
  1477.             tt_putp(delete_line);
  1478.         }
  1479.     } while(still_testing());
  1480.     home_down();
  1481.     put_str("This line should be on the top.");
  1482.     go_home();
  1483.     if (repeats || !delete_line) {
  1484.         tt_putparm(parm_delete_line, lines - 1, lines - 1, 0);
  1485.     } else {
  1486.         for (i = 1; i < lines; i++) {
  1487.             tt_putp(delete_line);
  1488.         }
  1489.     }
  1490.     sprintf(temp, "\nDelete %d line%s.  ", augment,
  1491.         augment == 1 ? "" : "s");
  1492.     put_str(temp);
  1493.     pad_test_shutdown(t, 0);
  1494.     pad_done_message(t, state, ch);
  1495. }
  1496.  
  1497. /*
  1498. **    pad_xl(test_list, status, ch)
  1499. **
  1500. **    Test (il1) Insert and (dl1) Delete lines
  1501. */
  1502. static void
  1503. pad_xl(
  1504.     struct test_list *t,
  1505.     int *state,
  1506.     int *ch)
  1507. {
  1508.     if (!insert_line && !delete_line) {
  1509.         /* quietly skip this test */
  1510.         return;
  1511.     }
  1512.     if (skip_pad_test(t, state, ch,
  1513.         "(il1) Insert-line, (dl1) Delete-line start testing")) {
  1514.         return;
  1515.     }
  1516.     put_clear();
  1517.     putln("\rThis text is written on the first line.");
  1518.     ptext("This sentence begins on the second line.  As this");
  1519.     ptext(" test runs the bottom part of this paragraph will");
  1520.     ptext(" jump up and down.  Don't worry, that's normal.  When");
  1521.     ptext(" the jumping stops, the entire paragraph should");
  1522.     ptext(" still be on the screen and in the same place as when");
  1523.     ptext(" the test started.  If this paragraph has scrolled");
  1524.     ptext(" off the top or bottom of the screen then the test");
  1525.     ptext(" has failed.  Scrolling off the top of the screen");
  1526.     ptext(" usually means that the delete line capability is");
  1527.     ptext(" working better than the insert line capability.  If");
  1528.     ptext(" the text scrolls off the bottom then delete line may");
  1529.     ptext(" be broken.  If parts of the text are missing then");
  1530.     ptext(" you should get professional help.");
  1531.     put_crlf();
  1532.     go_home();
  1533.     put_newlines(2);
  1534.     pad_test_startup(0);
  1535.     do {
  1536.         tt_putp(insert_line);
  1537.         put_cr();
  1538.         tt_putp(delete_line);
  1539.     } while(still_testing());
  1540.     pad_test_shutdown(t, 0);
  1541.     home_down();
  1542.     ptext("The top of the screen should have a paragraph of text.  ");
  1543.     pad_done_message(t, state, ch);
  1544. }
  1545.  
  1546. /*
  1547. **    pad_scrc(test_list, status, ch)
  1548. **
  1549. **    Test (sc) (rc) Save/restore cursor
  1550. */
  1551. static void
  1552. pad_scrc(
  1553.     struct test_list *t,
  1554.     int *state,
  1555.     int *ch)
  1556. {
  1557.     int i;
  1558.  
  1559.     if (!save_cursor || !restore_cursor) {
  1560.         CAP_NOT_FOUND;
  1561.         if (save_cursor) {
  1562.             ptext("(rc) Restore-cursor");
  1563.         } else
  1564.         if (restore_cursor) {
  1565.             ptext("(sc) Save-cursor");
  1566.         } else {
  1567.             ptext("(sc) Save-cursor, (rc) Restore-cursor");
  1568.         }
  1569.         ptext(" not present.  ");
  1570.         pad_done_message(t, state, ch);
  1571.         return;
  1572.     }
  1573.     if (skip_pad_test(t, state, ch,
  1574.         "(sc) (rc) Save/Restore-cursor start testing")) {
  1575.         return;
  1576.     }
  1577.     pad_test_startup(1);
  1578.     do {
  1579.         page_loop();
  1580.         for (i = 1; i < columns; i++) {
  1581.             tt_putp(save_cursor);
  1582.             putchp(letter);
  1583.             tt_putp(restore_cursor);
  1584.             putchp('X');
  1585.         }
  1586.     } while(still_testing());
  1587.     pad_test_shutdown(t, 0);
  1588.     home_down();
  1589.     ptext(above_line);
  1590.     pad_done_message(t, state, ch);
  1591. }
  1592.  
  1593. /*
  1594. **    pad_csrind(test_list, status, ch)
  1595. **
  1596. **    Test (csr) and (ind) Change scroll region and index.
  1597. */
  1598. static void
  1599. pad_csrind(
  1600.     struct test_list *t,
  1601.     int *state,
  1602.     int *ch)
  1603. {
  1604.     int i;
  1605.  
  1606.     if (!change_scroll_region) {
  1607.         CAP_NOT_FOUND;
  1608.         ptext("(csr) Change-scroll-region not present.  ");
  1609.         pad_done_message(t, state, ch);
  1610.         return;
  1611.     }
  1612.     if (skip_pad_test(t, state, ch,
  1613.         "(csr) Save/Restore-cursor, (ind) index start testing")) {
  1614.         return;
  1615.     }
  1616.     if (augment < 2) {
  1617.         augment = 2;
  1618.     }
  1619.     if (augment > lines - 1) {
  1620.         augment = lines - 1;
  1621.     }
  1622.     put_clear();
  1623.     ptext("This text is on the top line.");
  1624.     tt_putparm(change_scroll_region, 1, lines - augment, lines - 1);
  1625.     /* go to the bottom of the screen */
  1626.     home_down();
  1627.     pad_test_startup(0);
  1628.     do {
  1629.         sprintf(temp, "%d\r", test_complete);
  1630.         put_str(temp);
  1631.         put_ind();
  1632.     } while(still_testing());
  1633.     ptextln("(csr) is broken.");
  1634.     for (i = augment; i > 1; i--) {
  1635.         put_ind();
  1636.     }
  1637.     pad_test_shutdown(t, 0);
  1638.     ptext("All but top and bottom lines should be blank.  ");
  1639.     pad_done_message(t, state, ch);
  1640.     tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1641.     put_clear();
  1642. }
  1643.  
  1644. /*
  1645. **    pad_sccsrrc(test_list, status, ch)
  1646. **
  1647. **    Test (sc) (csr) and (rc) Save/Change/Restore scroll region
  1648. */
  1649. static void
  1650. pad_sccsrrc(
  1651.     struct test_list *t,
  1652.     int *state,
  1653.     int *ch)
  1654. {
  1655.     int i;
  1656.  
  1657.     if (!save_cursor || !change_scroll_region || !restore_cursor) {
  1658.         /* quietly ignore this test */
  1659.         return;
  1660.     }
  1661.     if (skip_pad_test(t, state, ch,
  1662.         "(sc) (csr) (rc) Save/Change/Restore-cursor, start testing")) {
  1663.         return;
  1664.     }
  1665.     pad_test_startup(1);
  1666.     do {
  1667.         page_loop();
  1668.         for (i = 1; i < columns; i++) {
  1669.             tt_putp(save_cursor);
  1670.             putchp(letter);
  1671.             tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1672.             tt_putp(restore_cursor);
  1673.             putchp('X');
  1674.         }
  1675.     } while(still_testing());
  1676.     pad_test_shutdown(t, 0);
  1677.     home_down();
  1678.     ptext(above_line);
  1679.     pad_done_message(t, state, ch);
  1680.     tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1681. }
  1682.  
  1683. /*
  1684. **    pad_csr_nel(test_list, status, ch)
  1685. **
  1686. **    Test (sc) (csr) (nel) and (rc) Save/Change/Restore scroll region
  1687. */
  1688. static void
  1689. pad_csr_nel(
  1690.     struct test_list *t,
  1691.     int *state,
  1692.     int *ch)
  1693. {
  1694.     int i, j;
  1695.  
  1696.     if (!save_cursor || !change_scroll_region || !restore_cursor) {
  1697.         /* quietly ignore this test */
  1698.         return;
  1699.     }
  1700.     if (skip_pad_test(t, state, ch,
  1701.         "(csr) Change-scroll-region, (nel) newline start testing")) {
  1702.         return;
  1703.     }
  1704.     pad_test_startup(1);
  1705.     do {
  1706.         for (i = 0; i < lines; i++) {
  1707.             for (j = lines - i; j > 0; j--) {
  1708.                 put_crlf();
  1709.             }
  1710.             tt_putp(save_cursor);
  1711.             tt_putparm(change_scroll_region, 1, i, lines - 1);
  1712.             tt_putp(restore_cursor);
  1713.             put_str(every_line);
  1714.         }
  1715.         tt_putp(save_cursor);
  1716.         tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1717.         tt_putp(restore_cursor);
  1718.     } while(still_testing());
  1719.     pad_test_shutdown(t, 0);
  1720.     put_str("  ");
  1721.     pad_done_message(t, state, ch);
  1722.     tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1723. }
  1724.  
  1725. /*
  1726. **    pad_csr_cup(test_list, status, ch)
  1727. **
  1728. **    Test (csr) (cup) Change scroll region and cursor address
  1729. */
  1730. static void
  1731. pad_csr_cup(
  1732.     struct test_list *t,
  1733.     int *state,
  1734.     int *ch)
  1735. {
  1736.     int i, j;
  1737.  
  1738.     if (!change_scroll_region || !cursor_address) {
  1739.         /* quietly ignore this test */
  1740.         return;
  1741.     }
  1742.     if (skip_pad_test(t, state, ch,
  1743.         "(csr) Change-scroll-region, (cup) cursor-address start testing")) {
  1744.         return;
  1745.     }
  1746.     pad_test_startup(1);
  1747.     do {
  1748.         for (i = 0; i < lines; i++) {
  1749.             for (j = lines - i; j > 0; j--) {
  1750.                 put_crlf();
  1751.             }
  1752.             tt_putparm(change_scroll_region, 1, i, lines - 1);
  1753.             tt_putparm(cursor_address, 1, lines - 1, 0);
  1754.             put_str(every_line);
  1755.         }
  1756.         tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1757.         tt_putparm(cursor_address, 1, lines - 1, strlen(every_line));
  1758.     } while(still_testing());
  1759.     pad_test_shutdown(t, 0);
  1760.     put_str("  ");
  1761.     pad_done_message(t, state, ch);
  1762.     tt_putparm(change_scroll_region, 1, 0, lines - 1);
  1763. }
  1764.  
  1765. /*
  1766. **    pad_ht(test_list, status, ch)
  1767. **
  1768. **    Test (ht) Tabs
  1769. */
  1770. static void
  1771. pad_ht(
  1772.     struct test_list *t,
  1773.     int *state,
  1774.     int *ch)
  1775. {
  1776.     int i, j;
  1777.  
  1778.     if (!set_tab && init_tabs <= 0) {
  1779.         CAP_NOT_FOUND;
  1780.         ptext("(ht) Tab not tested.  (hts) Set-tabs and (it) initial-tabs not present.  ");
  1781.         pad_done_message(t, state, ch);
  1782.         return;
  1783.     }
  1784.     if (skip_pad_test(t, state, ch, "(ht) Tab start testing")) {
  1785.         return;
  1786.     }
  1787.     pad_test_startup(1);
  1788.     do {
  1789.         /*
  1790.            it is not always possible to test tabs with caps
  1791.            that do not already have padding. The following
  1792.            test uses a mixed bag of tests in order to avoid
  1793.            this problem. Note: I do not scroll
  1794.         */
  1795.         if (auto_right_margin && can_go_home)
  1796.             for (i = 1, go_home(); i < lines - 2; i++) {
  1797.                 for (j = 8; j < columns; j += 8) {
  1798.                     putchp('\t');
  1799.                 }
  1800.                 put_str("A        ");
  1801.             }
  1802.         if (cursor_down && can_go_home)
  1803.             for (i = 1, go_home(); i < lines - 2; i++) {
  1804.                 for (j = 8; j < columns; j += 8) {
  1805.                     putchp('\t');
  1806.                 }
  1807.                 put_str("D\r");
  1808.                 tt_putp(cursor_down);
  1809.             }
  1810.         if (cursor_address)
  1811.             for (i = 1; i < lines - 2; i++) {
  1812.                 tt_putparm(cursor_address, 1, i - 1, 0);
  1813.                 for (j = 8; j < columns; j += 8) {
  1814.                     putchp('\t');
  1815.                 }
  1816.                 put_str("C");
  1817.             }
  1818.         go_home();
  1819.         for (i = 1; i < lines - 2; i++) {
  1820.             for (j = 8; j < columns; j += 8) {
  1821.                 putchp('\t');
  1822.             }
  1823.             putln("N");
  1824.         }
  1825.     } while(still_testing());
  1826.     pad_test_shutdown(t, 0);
  1827.     ptextln("Letters on the screen other than Ns at the right margin indicate failure.");
  1828.     ptext("A-(am) D-(cud1) C-(cup) N-(nel)  ");
  1829.     pad_done_message(t, state, ch);
  1830. }
  1831.  
  1832. /*
  1833. **    pad_smso(test_list, status, ch)
  1834. **
  1835. **    Test (smso) (rmso) Enter/exit mode
  1836. */
  1837. static void
  1838. pad_smso(
  1839.     struct test_list *t,
  1840.     int *state,
  1841.     int *ch)
  1842. {
  1843.     int i, j;
  1844.  
  1845.     if (!enter_standout_mode || !exit_standout_mode) {
  1846.         CAP_NOT_FOUND;
  1847.         ptext("(smso) (rmso) Enter/Exit-standout-mode not present.  ");
  1848.         pad_done_message(t, state, ch);
  1849.         return;
  1850.     }
  1851.     if (skip_pad_test(t, state, ch,
  1852.         "(smso) (rmso) Enter/Exit-standout-mode start testing")) {
  1853.         return;
  1854.     }
  1855.     /*
  1856.        In terminals that emulate non-hidden attributes with hidden
  1857.        attributes, the amount of time that it takes to fill the screen
  1858.        with an attribute is nontrivial. The following test is designed to
  1859.        catch those delays
  1860.     */
  1861.     pad_test_startup(1);
  1862.     do {
  1863.         page_loop();
  1864.         j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0;
  1865.         for (i = 2 + j + j; i < columns;) {
  1866.             put_mode(enter_standout_mode);
  1867.             i += j + j + 2;
  1868.             putchp('X');
  1869.             put_mode(exit_standout_mode);
  1870.             putchp('X');
  1871.         }
  1872.     } while(still_testing());
  1873.     pad_test_shutdown(t, 0);
  1874.     home_down();
  1875.     ptext(above_line);
  1876.     pad_done_message(t, state, ch);
  1877.     put_mode(exit_standout_mode);
  1878. }
  1879.  
  1880. /*
  1881. **    pad_smacs(test_list, status, ch)
  1882. **
  1883. **    Test (smacs) (rmacs) Enter/exit altcharset mode
  1884. */
  1885. static void
  1886. pad_smacs(
  1887.     struct test_list *t,
  1888.     int *state,
  1889.     int *ch)
  1890. {
  1891.     int i, j;
  1892.  
  1893.     /* test enter even if exit is missing */
  1894.     if (!enter_alt_charset_mode) {
  1895.         CAP_NOT_FOUND;
  1896.         ptext("(smacs) Enter-altcharset-mode not present.  ");
  1897.         pad_done_message(t, state, ch);
  1898.         return;
  1899.     }
  1900.     if (skip_pad_test(t, state, ch,
  1901.         "(smacs) (rmacs) Enter/Exit-altcharset-mode start testing")) {
  1902.         return;
  1903.     }
  1904.     pad_test_startup(1);
  1905.     do {
  1906.         page_loop();
  1907.         j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0;
  1908.         for (i = 2 + j + j; i < columns;) {
  1909.             put_mode(enter_alt_charset_mode);
  1910.             i += j + j + 2;
  1911.             putchp(letter);
  1912.             put_mode(exit_alt_charset_mode);
  1913.             putchp(letter);
  1914.         }
  1915.     } while(still_testing());
  1916.     pad_test_shutdown(t, 0);
  1917.     home_down();
  1918.     ptext("Every other character is from the alternate character set.  ");
  1919.     pad_done_message(t, state, ch);
  1920.     put_mode(exit_alt_charset_mode);
  1921. }
  1922.  
  1923. /*
  1924. **    pad_crash(test_list, status, ch)
  1925. **
  1926. **    Test (clear) without padding
  1927. */
  1928. static void
  1929. pad_crash(
  1930.     struct test_list *t,
  1931.     int *state,
  1932.     int *ch)
  1933. {
  1934.     int save_xon_xoff;
  1935.  
  1936.     if (!clear_screen) {
  1937.         ptext("(clear) Clear-screen not present.  ");
  1938.         pad_done_message(t, state, ch);
  1939.         return;
  1940.     }
  1941.     ptext("If you would like to see if the terminal will really lock up.");
  1942.     ptextln("  I will send the clear screen sequence without the pads.");
  1943.     if (skip_pad_test(t, state, ch,
  1944.         "(clear) Clear-screen start crash testing")) {
  1945.         return;
  1946.     }
  1947.     save_xon_xoff = xon_xoff;
  1948.     xon_xoff = 1;
  1949.     pad_test_startup(0);
  1950.     do {
  1951.         put_str("Erase this!");
  1952.         tt_putp(clear_screen);
  1953.     } while(still_testing());
  1954.     xon_xoff = save_xon_xoff;
  1955.     pad_test_shutdown(t, 1);
  1956.     pad_done_message(t, state, ch);
  1957. }
  1958.